第九章 评估（上）——存在一个简单的正确答案时

在过去的章节里，我们向你展示了如何借助 LLM 构建应用程序，包括评估输入，处理输入，以及在呈现结果给用户之前进行最后的结果检查。然而，在构建出这样的系统后，我们应如何确知其运行状况呢？更甚者，当我们将其部署并让用户开始使用之后，我们又该如何追踪其表现，发现可能存在的问题，并持续优化它的回答质量呢？在本章里，我们将向你分享一些评估LLM输出的最佳实践。

构建基于LLM的应用程序与构建传统的监督学习应用程序有所不同。因为你可以快速地构建出基于LLM的应用程序，所以评估通常不从测试集开始。相反，你会逐渐地建立起一个测试样例的集合。

在传统的监督学习环境下，你需要收集训练集、开发集，或者留出交叉验证集，在整个开发过程中都会用到它们。然而，如果你能够在几分钟内定义一个 Prompt ，并在几小时内得到反馈结果，那么停下来收集一千个测试样本就会显得极为繁琐。因为现在，你可以在没有任何训练样本的情况下得到结果。

因此，在使用LLM构建应用程序时，你可能会经历以下流程：首先，你会在一到三个样本的小样本中调整 Prompt ，尝试使其在这些样本上起效。随后，当你对系统进行进一步测试时，可能会遇到一些棘手的例子，这些例子无法通过 Prompt 或者算法解决。这就是使用 ChatGPT API 构建应用程序的开发者所面临的挑战。在这种情况下，你可以将这些额外的几个例子添加到你正在测试的集合中，有机地添加其他难以处理的例子。最终，你会将足够多的这些例子添加到你逐步扩大的开发集中，以至于手动运行每一个例子以测试 Prompt 变得有些不便。然后，你开始开发一些用于衡量这些小样本集性能的指标，例如平均准确度。这个过程的有趣之处在于，如果你觉得你的系统已经足够好了，你可以随时停止，不再进行改进。实际上，很多已经部署的应用程序就在第一步或第二步就停下来了，而且它们运行得非常好。

值得注意的是，很多大型模型的应用程序没有实质性的风险，即使它没有给出完全正确的答案。但是，对于一些高风险的应用，如若存在偏见或不适当的输出可能对某人造成伤害，那么收集测试集、严格评估系统的性能，以及确保它在使用前能做对事情，就显得尤为重要。然而，如果你仅仅是用它来总结文章供自己阅读，而不是给其他人看，那么可能带来的风险就会较小，你可以在这个过程中早早地停止，而不必付出收集大规模数据集的巨大代价。

现在让我们进入更实际的应用阶段，将刚才所学的理论知识转化为实践。让我们一起研究一些真实的数据，理解其结构并使用我们的工具来分析它们。在我们的案例中，我们获取一组分类信息及其产品名称。让我们执行以下代码，以查看这些分类信息及其产品名称

  1. import utils_zh
  3. products_and_category = utils_zh.get_products_and_category()
  4. products_and_category
  1. {'电脑和笔记本': ['TechPro 超极本',
  2.   'BlueWave 游戏本',
  3.   'PowerLite Convertible',
  4.   'TechPro Desktop',
  5.   'BlueWave Chromebook'],
  6.  '智能手机和配件': ['SmartX ProPhone'],
  7.  '专业手机': ['MobiTech PowerCase',
  8.   'SmartX MiniPhone',
  9.   'MobiTech Wireless Charger',
  10.   'SmartX EarBuds'],
  11.  '电视和家庭影院系统': ['CineView 4K TV',
  12.   'SoundMax Home Theater',
  13.   'CineView 8K TV',
  14.   'SoundMax Soundbar',
  15.   'CineView OLED TV'],
  16.  '游戏机和配件': ['GameSphere X',
  17.   'ProGamer Controller',
  18.   'GameSphere Y',
  19.   'ProGamer Racing Wheel',
  20.   'GameSphere VR Headset'],
  21.  '音频设备': ['AudioPhonic Noise-Canceling Headphones',
  22.   'WaveSound Bluetooth Speaker',
  23.   'AudioPhonic True Wireless Earbuds',
  24.   'WaveSound Soundbar',
  25.   'AudioPhonic Turntable'],
  26.  '相机和摄像机': ['FotoSnap DSLR Camera',
  27.   'ActionCam 4K',
  28.   'FotoSnap Mirrorless Camera',
  29.   'ZoomMaster Camcorder',
  30.   'FotoSnap Instant Camera']}

一、找出相关产品和类别名称

在我们进行开发时，通常需要处理和解析用户的输入。特别是在电商领域，可能会有各种各样的用户查询，例如：”我想要最贵的电脑”。我们需要一个能理解这种语境，并能给出相关产品和类别的工具。下面这段代码实现的功能就是这样。

首先我们定义了一个函数find_category_and_product_v1，这个函数的主要目的是从用户的输入中解析出产品和类别。这个函数需要两个参数：user_input代表用户的查询，products_and_category是一个字典，其中包含了产品类型和对应产品的信息。

在函数的开始，我们定义了一个分隔符delimiter，用来在客户服务查询中分隔内容。随后，我们创建了一条系统消息。这条消息主要解释了系统的运作方式：用户会提供客户服务查询，查询会被分隔符delimiter分隔。系统会输出一个Python列表，列表中的每个对象都是Json对象。每个对象会包含’类别’和’名称’两个字段，分别对应产品的类别和名称。

我们创建了一个名为messages的列表，用来存储这些示例对话以及用户的查询。最后，我们使用get_completion_from_messages函数处理这些消息，返回处理结果。

通过这段代码，我们可以看到如何通过对话的方式理解和处理用户的查询，以提供更好的用户体验。

  1. from tool import get_completion_from_messages
  3. def find_category_and_product_v1(user_input,products_and_category):
  4.     """
  5.     从用户输入中获取到产品和类别
  7.     参数：
  8.     user_input：用户的查询
  9.     products_and_category：产品类型和对应产品的字典
  10.     """
  12.     delimiter = "####"
  13.     system_message = f"""
  14.     您将提供客户服务查询。\
  15.     客户服务查询将用{delimiter}字符分隔。
  16.     输出一个 Python 列表，列表中的每个对象都是 Json 对象，每个对象的格式如下：
  17.         '类别': <电脑和笔记本, 智能手机和配件, 电视和家庭影院系统, \
  18.     游戏机和配件, 音频设备, 相机和摄像机中的一个>,
  19.     以及
  20.         '名称': <必须在下面允许的产品中找到的产品列表>
  22.     其中类别和产品必须在客户服务查询中找到。
  23.     如果提到了一个产品，它必须与下面允许的产品列表中的正确类别关联。
  24.     如果没有找到产品或类别，输出一个空列表。
  26.     根据产品名称和产品类别与客户服务查询的相关性，列出所有相关的产品。
  27.     不要从产品的名称中假设任何特性或属性，如相对质量或价格。
  29.     允许的产品以 JSON 格式提供。
  30.     每个项目的键代表类别。
  31.     每个项目的值是该类别中的产品列表。
  32.     允许的产品：{products_and_category}
  34.     """
  36.     few_shot_user_1 = """我想要最贵的电脑。"""
  37.     few_shot_assistant_1 = """ 
  38.     [{'category': '电脑和笔记本', \
  39. 'products': ['TechPro 超极本', 'BlueWave 游戏本', 'PowerLite Convertible', 'TechPro Desktop', 'BlueWave Chromebook']}]
  40.     """
  42.     messages =  [  
  43.     {'role':'system', 'content': system_message},    
  44.     {'role':'user', 'content': f"{delimiter}{few_shot_user_1}{delimiter}"},  
  45.     {'role':'assistant', 'content': few_shot_assistant_1 },
  46.     {'role':'user', 'content': f"{delimiter}{user_input}{delimiter}"},  
  47.     ] 
  48.     return get_completion_from_messages(messages)

二、在一些查询上进行评估

对上述系统，我们可以首先在一些简单查询上进行评估：

  1. # 第一个评估的查询
  2. customer_msg_0 = f"""如果我预算有限，我可以买哪款电视？"""
  4. products_by_category_0 = find_category_and_product_v1(customer_msg_0,
  5.                                                       products_and_category)
  6. print(products_by_category_0)
  1.     [{'category': '电视和家庭影院系统', 'products': ['CineView 4K TV', 'SoundMax Home Theater', 'CineView 8K TV', 'SoundMax Soundbar', 'CineView OLED TV']}]

输出了正确回答。

  1. customer_msg_1 = f"""我需要一个智能手机的充电器"""
  3. products_by_category_1 = find_category_and_product_v1(customer_msg_1,
  4.                                                       products_and_category)
  5. print(products_by_category_1)
  1.     [{'category': '智能手机和配件', 'products': ['MobiTech PowerCase', 'SmartX MiniPhone', 'MobiTech Wireless Charger', 'SmartX EarBuds']}]

输出了正确回答。

  1. customer_msg_2 = f"""
  2. 你们有哪些电脑？"""
  4. products_by_category_2 = find_category_and_product_v1(customer_msg_2,
  5.                                                       products_and_category)
  6. products_by_category_2
  1. " \n    [{'category': '电脑和笔记本', 'products': ['TechPro 超极本', 'BlueWave 游戏本', 'PowerLite Convertible', 'TechPro Desktop', 'BlueWave Chromebook']}]"

输出回答正确，但格式有误。

  1. customer_msg_3 = f"""
  2. 告诉我关于smartx pro手机和fotosnap相机的信息，那款DSLR的。
  3. 我预算有限，你们有哪些性价比高的电视推荐？"""
  5. products_by_category_3 = find_category_and_product_v1(customer_msg_3,
  6.                                                       products_and_category)
  7. print(products_by_category_3)
  1.     [{'category': '智能手机和配件', 'products': ['SmartX ProPhone']}, {'category': '相机和摄像机', 'products': ['FotoSnap DSLR Camera']}]
  3.     [{'category': '电视和家庭影院系统', 'products': ['CineView 4K TV', 'SoundMax Home Theater', 'CineView 8K TV', 'SoundMax Soundbar', 'CineView OLED TV']}]

它看起来像是输出了正确的数据，但没有按照要求的格式输出。这使得将其解析为 Python 字典列表更加困难。

三、更难的测试用例

接着，我们可以给出一些在实际使用中，模型表现不如预期的查询。

  1. customer_msg_4 = f"""
  2. 告诉我关于CineView电视的信息，那款8K的，还有Gamesphere游戏机，X款的。
  3. 我预算有限，你们有哪些电脑？"""
  5. products_by_category_4 = find_category_and_product_v1(customer_msg_4,products_and_category)
  6. print(products_by_category_4)
  1.     [{'category': '电视和家庭影院系统', 'products': ['CineView 4K TV', 'SoundMax Home Theater', 'CineView 8K TV', 'SoundMax Soundbar', 'CineView OLED TV']}]
  2.     [{'category': '游戏机和配件', 'products': ['GameSphere X', 'ProGamer Controller', 'GameSphere Y', 'ProGamer Racing Wheel', 'GameSphere VR Headset']}]
  3.     [{'category': '电脑和笔记本', 'products': ['TechPro 超极本', 'BlueWave 游戏本', 'PowerLite Convertible', 'TechPro Desktop', 'BlueWave Chromebook']}]

四、修改指令以处理难测试用例

综上，我们实现的最初版本在上述一些测试用例中表现不尽如人意。

为提升效果，我们在提示中添加了以下内容：不要输出任何不在 JSON 格式中的附加文本，并添加了第二个示例，使用用户和助手消息进行 few-shot 提示。

  1. def find_category_and_product_v2(user_input,products_and_category):
  2.     """
  3.     从用户输入中获取到产品和类别
  5.     添加：不要输出任何不符合 JSON 格式的额外文本。
  6.     添加了第二个示例（用于 few-shot 提示），用户询问最便宜的计算机。
  7.     在这两个 few-shot 示例中，显示的响应只是 JSON 格式的完整产品列表。
  9.     参数：
  10.     user_input：用户的查询
  11.     products_and_category：产品类型和对应产品的字典    
  12.     """
  13.     delimiter = "####"
  14.     system_message = f"""
  15.     您将提供客户服务查询。\
  16.     客户服务查询将用{delimiter}字符分隔。
  17.     输出一个 Python列表，列表中的每个对象都是 JSON 对象，每个对象的格式如下：
  18.         '类别': <电脑和笔记本, 智能手机和配件, 电视和家庭影院系统, \
  19.     游戏机和配件, 音频设备, 相机和摄像机中的一个>,
  20.     以及
  21.         '名称': <必须在下面允许的产品中找到的产品列表>
  22.     不要输出任何不是 JSON 格式的额外文本。
  23.     输出请求的 JSON 后，不要写任何解释性的文本。
  25.     其中类别和产品必须在客户服务查询中找到。
  26.     如果提到了一个产品，它必须与下面允许的产品列表中的正确类别关联。
  27.     如果没有找到产品或类别，输出一个空列表。
  29.     根据产品名称和产品类别与客户服务查询的相关性，列出所有相关的产品。
  30.     不要从产品的名称中假设任何特性或属性，如相对质量或价格。
  32.     允许的产品以 JSON 格式提供。
  33.     每个项目的键代表类别。
  34.     每个项目的值是该类别中的产品列表。
  35.     允许的产品：{products_and_category}
  37.     """
  39.     few_shot_user_1 = """我想要最贵的电脑。你推荐哪款？"""
  40.     few_shot_assistant_1 = """ 
  41.     [{'category': '电脑和笔记本', \
  42. 'products': ['TechPro 超极本', 'BlueWave 游戏本', 'PowerLite Convertible', 'TechPro Desktop', 'BlueWave Chromebook']}]
  43.      """
  45.     few_shot_user_2 = """我想要最便宜的电脑。你推荐哪款？"""
  46.     few_shot_assistant_2 = """ 
  47.     [{'category': '电脑和笔记本', \
  48. 'products': ['TechPro 超极本', 'BlueWave 游戏本', 'PowerLite Convertible', 'TechPro Desktop', 'BlueWave Chromebook']}]
  49.     """
  51.     messages =  [  
  52.     {'role':'system', 'content': system_message},    
  53.     {'role':'user', 'content': f"{delimiter}{few_shot_user_1}{delimiter}"},  
  54.     {'role':'assistant', 'content': few_shot_assistant_1 },
  55.     {'role':'user', 'content': f"{delimiter}{few_shot_user_2}{delimiter}"},  
  56.     {'role':'assistant', 'content': few_shot_assistant_2 },
  57.     {'role':'user', 'content': f"{delimiter}{user_input}{delimiter}"},  
  58.     ] 
  59.     return get_completion_from_messages(messages)

五、在难测试用例上评估修改后的指令

我们可以在之前表现不如预期的较难测试用例上评估改进后系统的效果：

  1. customer_msg_3 = f"""
  2. 告诉我关于smartx pro手机和fotosnap相机的信息，那款DSLR的。
  3. 另外，你们有哪些电视？"""
  5. products_by_category_3 = find_category_and_product_v2(customer_msg_3,
  6.                                                       products_and_category)
  7. print(products_by_category_3)
  1.     [{'category': '智能手机和配件', 'products': ['SmartX ProPhone']}, {'category': '相机和摄像机', 'products': ['FotoSnap DSLR Camera', 'ActionCam 4K', 'FotoSnap Mirrorless Camera', 'ZoomMaster Camcorder', 'FotoSnap Instant Camera']}, {'category': '电视和家庭影院系统', 'products': ['CineView 4K TV', 'SoundMax Home Theater', 'CineView 8K TV', 'SoundMax Soundbar', 'CineView OLED TV']}]

六、回归测试：验证模型在以前的测试用例上仍然有效

检查并修复模型以提高难以测试的用例效果，同时确保此修正不会对先前的测试用例性能造成负面影响。

  1. customer_msg_0 = f"""如果我预算有限，我可以买哪款电视？"""
  3. products_by_category_0 = find_category_and_product_v2(customer_msg_0,
  4.                                                       products_and_category)
  5. print(products_by_category_0)
  1.     [{'category': '电视和家庭影院系统', 'products': ['CineView 4K TV', 'SoundMax Home Theater', 'CineView 8K TV', 'SoundMax Soundbar', 'CineView OLED TV']}]

七、收集开发集进行自动化测试

当我们的应用程序逐渐成熟，测试的重要性也随之增加。通常，当我们仅处理少量样本，手动运行测试并对结果进行评估是可行的。然而，随着开发集的增大，这种方法变得既繁琐又低效。此时，就需要引入自动化测试来提高我们的工作效率。下面将开始编写代码来自动化测试流程，可以帮助您提升效率并确保测试的准确率。

以下是一些用户问题的标准答案，用于评估 LLM 回答的准确度，与机器学习中的验证集的作用相当。

  1. msg_ideal_pairs_set = [
  3.     # eg 0
  4.     {'customer_msg':"""如果我预算有限，我可以买哪种电视？""",
  5.      'ideal_answer':{
  6.         '电视和家庭影院系统':set(
  7.             ['CineView 4K TV', 'SoundMax Home Theater', 'CineView 8K TV', 'SoundMax Soundbar', 'CineView OLED TV']
  8.         )}
  9.     },
  11.     # eg 1
  12.     {'customer_msg':"""我需要一个智能手机的充电器""",
  13.      'ideal_answer':{
  14.         '智能手机和配件':set(
  15.             ['MobiTech PowerCase', 'MobiTech Wireless Charger', 'SmartX EarBuds']
  16.         )}
  17.     },
  18.     # eg 2
  19.     {'customer_msg':f"""你有什么样的电脑""",
  20.      'ideal_answer':{
  21.            '电脑和笔记本':set(
  22.                ['TechPro 超极本', 'BlueWave 游戏本', 'PowerLite Convertible', 'TechPro Desktop', 'BlueWave Chromebook'
  23.                ])
  24.                 }
  25.     },
  27.     # eg 3
  28.     {'customer_msg':f"""告诉我关于smartx pro手机和fotosnap相机的信息，那款DSLR的。\
  29. 另外，你们有哪些电视？""",
  30.      'ideal_answer':{
  31.         '智能手机和配件':set(
  32.             ['SmartX ProPhone']),
  33.         '相机和摄像机':set(
  34.             ['FotoSnap DSLR Camera']),
  35.         '电视和家庭影院系统':set(
  36.             ['CineView 4K TV', 'SoundMax Home Theater','CineView 8K TV', 'SoundMax Soundbar', 'CineView OLED TV'])
  37.         }
  38.     }, 
  40.     # eg 4
  41.     {'customer_msg':"""告诉我关于CineView电视，那款8K电视、\
  42.      Gamesphere游戏机和X游戏机的信息。我的预算有限，你们有哪些电脑？""",
  43.      'ideal_answer':{
  44.         '电视和家庭影院系统':set(
  45.             ['CineView 8K TV']),
  46.         '游戏机和配件':set(
  47.             ['GameSphere X']),
  48.         '电脑和笔记本':set(
  49.             ['TechPro Ultrabook', 'BlueWave Gaming Laptop', 'PowerLite Convertible', 'TechPro Desktop', 'BlueWave Chromebook'])
  50.         }
  51.     },
  53.     # eg 5
  54.     {'customer_msg':f"""你们有哪些智能手机""",
  55.      'ideal_answer':{
  56.            '智能手机和配件':set(
  57.                ['SmartX ProPhone', 'MobiTech PowerCase', 'SmartX MiniPhone', 'MobiTech Wireless Charger', 'SmartX EarBuds'
  58.                ])
  59.                     }
  60.     },
  61.     # eg 6
  62.     {'customer_msg':f"""我预算有限。你能向我推荐一些智能手机吗？""",
  63.      'ideal_answer':{
  64.         '智能手机和配件':set(
  65.             ['SmartX EarBuds', 'SmartX MiniPhone', 'MobiTech PowerCase', 'SmartX ProPhone', 'MobiTech Wireless Charger']
  66.         )}
  67.     },
  69.     # eg 7 # this will output a subset of the ideal answer
  70.     {'customer_msg':f"""有哪些游戏机适合我喜欢赛车游戏的朋友？""",
  71.      'ideal_answer':{
  72.         '游戏机和配件':set([
  73.             'GameSphere X',
  74.             'ProGamer Controller',
  75.             'GameSphere Y',
  76.             'ProGamer Racing Wheel',
  77.             'GameSphere VR Headset'
  78.      ])}
  79.     },
  80.     # eg 8
  81.     {'customer_msg':f"""送给我摄像师朋友什么礼物合适？""",
  82.      'ideal_answer': {
  83.         '相机和摄像机':set([
  84.         'FotoSnap DSLR Camera', 'ActionCam 4K', 'FotoSnap Mirrorless Camera', 'ZoomMaster Camcorder', 'FotoSnap Instant Camera'
  85.         ])}
  86.     },
  88.     # eg 9
  89.     {'customer_msg':f"""我想要一台热水浴缸时光机""",
  90.      'ideal_answer': []
  91.     }
  93. ]

八、通过与理想答案比较来评估测试用例

我们通过以下函数eval_response_with_ideal来评估 LLM 回答的准确度，该函数通过将 LLM 回答与理想答案进行比较来评估系统在测试用例上的效果。

  1. import json
  2. def eval_response_with_ideal(response,
  3.                               ideal,
  4.                               debug=False):
  5.     """
  6.     评估回复是否与理想答案匹配
  8.     参数：
  9.     response: 回复的内容
  10.     ideal: 理想的答案
  11.     debug: 是否打印调试信息
  12.     """
  13.     if debug:
  14.         print("回复：")
  15.         print(response)
  17.     # json.loads() 只能解析双引号，因此此处将单引号替换为双引号
  18.     json_like_str = response.replace("'",'"')
  20.     # 解析为一系列的字典
  21.     l_of_d = json.loads(json_like_str)
  23.     # 当响应为空，即没有找到任何商品时
  24.     if l_of_d == [] and ideal == []:
  25.         return 1
  27.     # 另外一种异常情况是，标准答案数量与回复答案数量不匹配
  28.     elif l_of_d == [] or ideal == []:
  29.         return 0
  31.     # 统计正确答案数量
  32.     correct = 0    
  34.     if debug:
  35.         print("l_of_d is")
  36.         print(l_of_d)
  38.     # 对每一个问答对  
  39.     for d in l_of_d:
  41.         # 获取产品和目录
  42.         cat = d.get('category')
  43.         prod_l = d.get('products')
  44.         # 有获取到产品和目录
  45.         if cat and prod_l:
  46.             # convert list to set for comparison
  47.             prod_set = set(prod_l)
  48.             # get ideal set of products
  49.             ideal_cat = ideal.get(cat)
  50.             if ideal_cat:
  51.                 prod_set_ideal = set(ideal.get(cat))
  52.             else:
  53.                 if debug:
  54.                     print(f"没有在标准答案中找到目录 {cat}")
  55.                     print(f"标准答案: {ideal}")
  56.                 continue
  58.             if debug:
  59.                 print("产品集合：\n",prod_set)
  60.                 print()
  61.                 print("标准答案的产品集合：\n",prod_set_ideal)
  63.             # 查找到的产品集合和标准的产品集合一致
  64.             if prod_set == prod_set_ideal:
  65.                 if debug:
  66.                     print("正确")
  67.                 correct +=1
  68.             else:
  69.                 print("错误")
  70.                 print(f"产品集合: {prod_set}")
  71.                 print(f"标准的产品集合: {prod_set_ideal}")
  72.                 if prod_set <= prod_set_ideal:
  73.                     print("回答是标准答案的一个子集")
  74.                 elif prod_set >= prod_set_ideal:
  75.                     print("回答是标准答案的一个超集")
  77.     # 计算正确答案数
  78.     pc_correct = correct / len(l_of_d)
  80.     return pc_correct

我们使用上述测试用例中的一个进行测试，首先看一下标准回答：

  1. print(f'用户提问: {msg_ideal_pairs_set[7]["customer_msg"]}')
  2. print(f'标准答案: {msg_ideal_pairs_set[7]["ideal_answer"]}')
  1. 用户提问: 有哪些游戏机适合我喜欢赛车游戏的朋友？
  2. 标准答案: {'游戏机和配件': {'ProGamer Racing Wheel', 'ProGamer Controller', 'GameSphere Y', 'GameSphere VR Headset', 'GameSphere X'}}

再对比 LLM 回答，并使用验证函数进行评分：

  1. response = find_category_and_product_v2(msg_ideal_pairs_set[7]["customer_msg"],
  2.                                          products_and_category)
  3. print(f'回答: {response}')
  5. eval_response_with_ideal(response,
  6.                               msg_ideal_pairs_set[7]["ideal_answer"])
  1. 回答:  
  2.     [{'category': '游戏机和配件', 'products': ['GameSphere X', 'ProGamer Controller', 'GameSphere Y', 'ProGamer Racing Wheel', 'GameSphere VR Headset']}]
  9. 1.0

可见该验证函数的打分是准确的。

九、在所有测试用例上运行评估，并计算正确的用例比例

下面我们来对测试用例中的全部问题进行验证，并计算 LLM 回答正确的准确率

注意：如果任何 API 调用超时，将无法运行

  1. import time
  3. score_accum = 0
  4. for i, pair in enumerate(msg_ideal_pairs_set):
  5.     time.sleep(20)
  6.     print(f"示例 {i}")
  8.     customer_msg = pair['customer_msg']
  9.     ideal = pair['ideal_answer']
  11.     # print("Customer message",customer_msg)
  12.     # print("ideal:",ideal)
  13.     response = find_category_and_product_v2(customer_msg,
  14.                                                       products_and_category)
  17.     # print("products_by_category",products_by_category)
  18.     score = eval_response_with_ideal(response,ideal,debug=False)
  19.     print(f"{i}: {score}")
  20.     score_accum += score
  23. n_examples = len(msg_ideal_pairs_set)
  24. fraction_correct = score_accum / n_examples
  25. print(f"正确比例为 {n_examples}: {fraction_correct}")
  1. 示例 0
  2. 0: 1.0
  3. 示例 1
  4. 错误
  5. 产品集合: {'SmartX ProPhone'}
  6. 标准的产品集合: {'MobiTech Wireless Charger', 'SmartX EarBuds', 'MobiTech PowerCase'}
  7. 1: 0.0
  8. 示例 2
  9. 2: 1.0
  10. 示例 3
  11. 3: 1.0
  12. 示例 4
  13. 错误
  14. 产品集合: {'SoundMax Home Theater', 'CineView 8K TV', 'CineView 4K TV', 'CineView OLED TV', 'SoundMax Soundbar'}
  15. 标准的产品集合: {'CineView 8K TV'}
  16. 回答是标准答案的一个超集
  17. 错误
  18. 产品集合: {'ProGamer Racing Wheel', 'ProGamer Controller', 'GameSphere Y', 'GameSphere VR Headset', 'GameSphere X'}
  19. 标准的产品集合: {'GameSphere X'}
  20. 回答是标准答案的一个超集
  21. 错误
  22. 产品集合: {'TechPro 超极本', 'TechPro Desktop', 'BlueWave Chromebook', 'PowerLite Convertible', 'BlueWave 游戏本'}
  23. 标准的产品集合: {'TechPro Desktop', 'BlueWave Chromebook', 'TechPro Ultrabook', 'PowerLite Convertible', 'BlueWave Gaming Laptop'}
  24. 4: 0.0
  25. 示例 5
  26. 错误
  27. 产品集合: {'SmartX ProPhone'}
  28. 标准的产品集合: {'MobiTech Wireless Charger', 'SmartX EarBuds', 'SmartX MiniPhone', 'SmartX ProPhone', 'MobiTech PowerCase'}
  29. 回答是标准答案的一个子集
  30. 5: 0.0
  31. 示例 6
  32. 错误
  33. 产品集合: {'SmartX ProPhone'}
  34. 标准的产品集合: {'MobiTech Wireless Charger', 'SmartX EarBuds', 'SmartX MiniPhone', 'SmartX ProPhone', 'MobiTech PowerCase'}
  35. 回答是标准答案的一个子集
  36. 6: 0.0
  37. 示例 7
  38. 7: 1.0
  39. 示例 8
  40. 8: 1.0
  41. 示例 9
  42. 9: 1
  43. 正确比例为 10: 0.6

使用 Prompt 构建应用程序的工作流程与使用监督学习构建应用程序的工作流程非常不同。因此，我们认为这是需要记住的一件好事，当您正在构建监督学习模型时，会感觉到迭代速度快了很多。

如果您并未亲身体验，可能会惊叹于仅有手动构建的极少样本，就可以产生高效的评估方法。您可能会认为，仅有 10 个样本是不具备统计意义的。但当您真正运用这种方式时，您可能会对向开发集中添加一些复杂样本所带来的效果提升感到惊讶。这对于帮助您和您的团队找到有效的 Prompt 和有效的系统非常有帮助。

在本章中，输出可以被定量评估，就像有一个期望的输出一样，您可以判断它是否给出了这个期望的输出。在下一章中，我们将探讨如何在更加模糊的情况下评估我们的输出。即正确答案可能不那么明确的情况。

十、英文版

1. 找出产品和类别名称

  1. import utils_en
  3. products_and_category = utils_en.get_products_and_category()
  4. products_and_category
  1. {'Computers and Laptops': ['TechPro Ultrabook',
  2.   'BlueWave Gaming Laptop',
  3.   'PowerLite Convertible',
  4.   'TechPro Desktop',
  5.   'BlueWave Chromebook'],
  6.  'Smartphones and Accessories': ['SmartX ProPhone',
  7.   'MobiTech PowerCase',
  8.   'SmartX MiniPhone',
  9.   'MobiTech Wireless Charger',
  10.   'SmartX EarBuds'],
  11.  'Televisions and Home Theater Systems': ['CineView 4K TV',
  12.   'SoundMax Home Theater',
  13.   'CineView 8K TV',
  14.   'SoundMax Soundbar',
  15.   'CineView OLED TV'],
  16.  'Gaming Consoles and Accessories': ['GameSphere X',
  17.   'ProGamer Controller',
  18.   'GameSphere Y',
  19.   'ProGamer Racing Wheel',
  20.   'GameSphere VR Headset'],
  21.  'Audio Equipment': ['AudioPhonic Noise-Canceling Headphones',
  22.   'WaveSound Bluetooth Speaker',
  23.   'AudioPhonic True Wireless Earbuds',
  24.   'WaveSound Soundbar',
  25.   'AudioPhonic Turntable'],
  26.  'Cameras and Camcorders': ['FotoSnap DSLR Camera',
  27.   'ActionCam 4K',
  28.   'FotoSnap Mirrorless Camera',
  29.   'ZoomMaster Camcorder',
  30.   'FotoSnap Instant Camera']}
  1. def find_category_and_product_v1(user_input, products_and_category):
  2.     """
  3.     从用户输入中获取到产品和类别
  5.     参数：
  6.     user_input：用户的查询
  7.     products_and_category：产品类型和对应产品的字典
  8.     """
  10.     # 分隔符
  11.     delimiter = "####"
  12.     # 定义的系统信息，陈述了需要 GPT 完成的工作
  13.     system_message = f"""
  14.     You will be provided with customer service queries. \
  15.     The customer service query will be delimited with {delimiter} characters.
  16.     Output a Python list of json objects, where each object has the following format:
  17.         'category': <one of Computers and Laptops, Smartphones and Accessories, Televisions and Home Theater Systems, \
  18.     Gaming Consoles and Accessories, Audio Equipment, Cameras and Camcorders>,
  19.     AND
  20.         'products': <a list of products that must be found in the allowed products below>
  23.     Where the categories and products must be found in the customer service query.
  24.     If a product is mentioned, it must be associated with the correct category in the allowed products list below.
  25.     If no products or categories are found, output an empty list.
  28.     List out all products that are relevant to the customer service query based on how closely it relates
  29.     to the product name and product category.
  30.     Do not assume, from the name of the product, any features or attributes such as relative quality or price.
  32.     The allowed products are provided in JSON format.
  33.     The keys of each item represent the category.
  34.     The values of each item is a list of products that are within that category.
  35.     Allowed products: {products_and_category}
  38.     """
  39.     # 给出几个示例
  40.     few_shot_user_1 = """I want the most expensive computer."""
  41.     few_shot_assistant_1 = """ 
  42.     [{'category': 'Computers and Laptops', \
  43. 'products': ['TechPro Ultrabook', 'BlueWave Gaming Laptop', 'PowerLite Convertible', 'TechPro Desktop', 'BlueWave Chromebook']}]
  44.     """
  46.     messages =  [  
  47.     {'role':'system', 'content': system_message},    
  48.     {'role':'user', 'content': f"{delimiter}{few_shot_user_1}{delimiter}"},  
  49.     {'role':'assistant', 'content': few_shot_assistant_1 },
  50.     {'role':'user', 'content': f"{delimiter}{user_input}{delimiter}"},  
  51.     ] 
  52.     return get_completion_from_messages(messages)

2. 在一些查询上进行评估

  1. # 第一个评估的查询
  2. customer_msg_0 = f"""Which TV can I buy if I'm on a budget?"""
  4. products_by_category_0 = find_category_and_product_v1(customer_msg_0,
  5.                                                       products_and_category)
  6. print(products_by_category_0)
  1.     [{'category': 'Televisions and Home Theater Systems', 'products': ['CineView 4K TV', 'SoundMax Home Theater', 'CineView 8K TV', 'SoundMax Soundbar', 'CineView OLED TV']}]
  1. # 第二个评估的查询
  2. customer_msg_1 = f"""I need a charger for my smartphone"""
  4. products_by_category_1 = find_category_and_product_v1(customer_msg_1,
  5.                                                       products_and_category)
  6. print(products_by_category_1)
  1.     [{'category': 'Smartphones and Accessories', 'products': ['MobiTech PowerCase', 'MobiTech Wireless Charger', 'SmartX EarBuds']}]
  1. # 第三个评估查询
  2. customer_msg_2 = f"""
  3. What computers do you have?"""
  5. products_by_category_2 = find_category_and_product_v1(customer_msg_2,
  6.                                                       products_and_category)
  7. products_by_category_2
  1. " \n    [{'category': 'Computers and Laptops', 'products': ['TechPro Ultrabook', 'BlueWave Gaming Laptop', 'PowerLite Convertible', 'TechPro Desktop', 'BlueWave Chromebook']}]"
  1. # 第四个查询，更复杂
  2. customer_msg_3 = f"""
  3. tell me about the smartx pro phone and the fotosnap camera, the dslr one.
  4. Also, what TVs do you have?"""
  6. products_by_category_3 = find_category_and_product_v1(customer_msg_3,
  7.                                                       products_and_category)
  8. print(products_by_category_3)
  1.     [{'category': 'Smartphones and Accessories', 'products': ['SmartX ProPhone']}, {'category': 'Cameras and Camcorders', 'products': ['FotoSnap DSLR Camera']}, {'category': 'Televisions and Home Theater Systems', 'products': ['CineView 4K TV', 'SoundMax Home Theater', 'CineView 8K TV', 'SoundMax Soundbar', 'CineView OLED TV']}]

3. 更难的测试用例

  1. customer_msg_4 = f"""
  2. tell me about the CineView TV, the 8K one, Gamesphere console, the X one.
  3. I'm on a budget, what computers do you have?"""
  5. products_by_category_4 = find_category_and_product_v1(customer_msg_4,
  6.                                                       products_and_category)
  7. print(products_by_category_4)
  1.     [{'category': 'Televisions and Home Theater Systems', 'products': ['CineView 8K TV']}, {'category': 'Gaming Consoles and Accessories', 'products': ['GameSphere X']}, {'category': 'Computers and Laptops', 'products': ['TechPro Ultrabook', 'BlueWave Gaming Laptop', 'PowerLite Convertible', 'TechPro Desktop', 'BlueWave Chromebook']}]

4. 修改指令

  1. def find_category_and_product_v2(user_input, products_and_category):
  2.     """
  3.     从用户输入中获取到产品和类别
  4.     添加：不要输出任何不符合 JSON 格式的额外文本。
  5.     添加了第二个示例（用于 few-shot 提示），用户询问最便宜的计算机。
  6.     在这两个 few-shot 示例中，显示的响应只是 JSON 格式的完整产品列表。
  8.     参数：
  9.     user_input：用户的查询
  10.     products_and_category：产品类型和对应产品的字典
  11.     """
  12.     delimiter = "####"
  13.     system_message = f"""
  14.     You will be provided with customer service queries. \
  15.     The customer service query will be delimited with {delimiter} characters.
  16.     Output a Python list of JSON objects, where each object has the following format:
  17.         'category': <one of Computers and Laptops, Smartphones and Accessories, Televisions and Home Theater Systems, \
  18.     Gaming Consoles and Accessories, Audio Equipment, Cameras and Camcorders>,
  19.     AND
  20.         'products': <a list of products that must be found in the allowed products below>
  21.     Do not output any additional text that is not in JSON format.
  22.     Do not write any explanatory text after outputting the requested JSON.
  25.     Where the categories and products must be found in the customer service query.
  26.     If a product is mentioned, it must be associated with the correct category in the allowed products list below.
  27.     If no products or categories are found, output an empty list.
  30.     List out all products that are relevant to the customer service query based on how closely it relates
  31.     to the product name and product category.
  32.     Do not assume, from the name of the product, any features or attributes such as relative quality or price.
  34.     The allowed products are provided in JSON format.
  35.     The keys of each item represent the category.
  36.     The values of each item is a list of products that are within that category.
  37.     Allowed products: {products_and_category}
  40.     """
  42.     few_shot_user_1 = """I want the most expensive computer. What do you recommend?"""
  43.     few_shot_assistant_1 = """ 
  44.     [{'category': 'Computers and Laptops', \
  45. 'products': ['TechPro Ultrabook', 'BlueWave Gaming Laptop', 'PowerLite Convertible', 'TechPro Desktop', 'BlueWave Chromebook']}]
  46.     """
  48.     few_shot_user_2 = """I want the most cheapest computer. What do you recommend?"""
  49.     few_shot_assistant_2 = """ 
  50.     [{'category': 'Computers and Laptops', \
  51. 'products': ['TechPro Ultrabook', 'BlueWave Gaming Laptop', 'PowerLite Convertible', 'TechPro Desktop', 'BlueWave Chromebook']}]
  52.     """
  54.     messages =  [  
  55.     {'role':'system', 'content': system_message},    
  56.     {'role':'user', 'content': f"{delimiter}{few_shot_user_1}{delimiter}"},  
  57.     {'role':'assistant', 'content': few_shot_assistant_1 },
  58.     {'role':'user', 'content': f"{delimiter}{few_shot_user_2}{delimiter}"},  
  59.     {'role':'assistant', 'content': few_shot_assistant_2 },
  60.     {'role':'user', 'content': f"{delimiter}{user_input}{delimiter}"},  
  61.     ] 
  62.     return get_completion_from_messages(messages)

5. 进一步评估

  1. customer_msg_3 = f"""
  2. tell me about the smartx pro phone and the fotosnap camera, the dslr one.
  3. Also, what TVs do you have?"""
  5. products_by_category_3 = find_category_and_product_v2(customer_msg_3,
  6.                                                       products_and_category)
  7. print(products_by_category_3)
  1.     [{'category': 'Smartphones and Accessories', 'products': ['SmartX ProPhone']}, {'category': 'Cameras and Camcorders', 'products': ['FotoSnap DSLR Camera']}, {'category': 'Televisions and Home Theater Systems', 'products': ['CineView 4K TV', 'SoundMax Home Theater', 'CineView 8K TV', 'SoundMax Soundbar', 'CineView OLED TV']}]

6. 回归测试

  1. customer_msg_0 = f"""Which TV can I buy if I'm on a budget?"""
  3. products_by_category_0 = find_category_and_product_v2(customer_msg_0,
  4.                                                       products_and_category)
  5. print(products_by_category_0)
  1.     [{'category': 'Televisions and Home Theater Systems', 'products': ['CineView 4K TV', 'SoundMax Home Theater', 'CineView 8K TV', 'SoundMax Soundbar', 'CineView OLED TV']}]

7. 自动化测试

  1. msg_ideal_pairs_set = [
  3.     # eg 0
  4.     {'customer_msg':"""Which TV can I buy if I'm on a budget?""",
  5.      'ideal_answer':{
  6.         'Televisions and Home Theater Systems':set(
  7.             ['CineView 4K TV', 'SoundMax Home Theater', 'CineView 8K TV', 'SoundMax Soundbar', 'CineView OLED TV']
  8.         )}
  9.     },
  11.     # eg 1
  12.     {'customer_msg':"""I need a charger for my smartphone""",
  13.      'ideal_answer':{
  14.         'Smartphones and Accessories':set(
  15.             ['MobiTech PowerCase', 'MobiTech Wireless Charger', 'SmartX EarBuds']
  16.         )}
  17.     },
  18.     # eg 2
  19.     {'customer_msg':f"""What computers do you have?""",
  20.      'ideal_answer':{
  21.            'Computers and Laptops':set(
  22.                ['TechPro Ultrabook', 'BlueWave Gaming Laptop', 'PowerLite Convertible', 'TechPro Desktop', 'BlueWave Chromebook'
  23.                ])
  24.                 }
  25.     },
  27.     # eg 3
  28.     {'customer_msg':f"""tell me about the smartx pro phone and \
  29.     the fotosnap camera, the dslr one.\
  30.     Also, what TVs do you have?""",
  31.      'ideal_answer':{
  32.         'Smartphones and Accessories':set(
  33.             ['SmartX ProPhone']),
  34.         'Cameras and Camcorders':set(
  35.             ['FotoSnap DSLR Camera']),
  36.         'Televisions and Home Theater Systems':set(
  37.             ['CineView 4K TV', 'SoundMax Home Theater','CineView 8K TV', 'SoundMax Soundbar', 'CineView OLED TV'])
  38.         }
  39.     }, 
  41.     # eg 4
  42.     {'customer_msg':"""tell me about the CineView TV, the 8K one, Gamesphere console, the X one.
  43. I'm on a budget, what computers do you have?""",
  44.      'ideal_answer':{
  45.         'Televisions and Home Theater Systems':set(
  46.             ['CineView 8K TV']),
  47.         'Gaming Consoles and Accessories':set(
  48.             ['GameSphere X']),
  49.         'Computers and Laptops':set(
  50.             ['TechPro Ultrabook', 'BlueWave Gaming Laptop', 'PowerLite Convertible', 'TechPro Desktop', 'BlueWave Chromebook'])
  51.         }
  52.     },
  54.     # eg 5
  55.     {'customer_msg':f"""What smartphones do you have?""",
  56.      'ideal_answer':{
  57.            'Smartphones and Accessories':set(
  58.                ['SmartX ProPhone', 'MobiTech PowerCase', 'SmartX MiniPhone', 'MobiTech Wireless Charger', 'SmartX EarBuds'
  59.                ])
  60.                     }
  61.     },
  62.     # eg 6
  63.     {'customer_msg':f"""I'm on a budget.  Can you recommend some smartphones to me?""",
  64.      'ideal_answer':{
  65.         'Smartphones and Accessories':set(
  66.             ['SmartX EarBuds', 'SmartX MiniPhone', 'MobiTech PowerCase', 'SmartX ProPhone', 'MobiTech Wireless Charger']
  67.         )}
  68.     },
  70.     # eg 7 # this will output a subset of the ideal answer
  71.     {'customer_msg':f"""What Gaming consoles would be good for my friend who is into racing games?""",
  72.      'ideal_answer':{
  73.         'Gaming Consoles and Accessories':set([
  74.             'GameSphere X',
  75.             'ProGamer Controller',
  76.             'GameSphere Y',
  77.             'ProGamer Racing Wheel',
  78.             'GameSphere VR Headset'
  79.      ])}
  80.     },
  81.     # eg 8
  82.     {'customer_msg':f"""What could be a good present for my videographer friend?""",
  83.      'ideal_answer': {
  84.         'Cameras and Camcorders':set([
  85.         'FotoSnap DSLR Camera', 'ActionCam 4K', 'FotoSnap Mirrorless Camera', 'ZoomMaster Camcorder', 'FotoSnap Instant Camera'
  86.         ])}
  87.     },
  89.     # eg 9
  90.     {'customer_msg':f"""I would like a hot tub time machine.""",
  91.      'ideal_answer': []
  92.     }
  94. ]

8. 与理想答案对比

  1. import json
  2. def eval_response_with_ideal(response,
  3.                               ideal,
  4.                               debug=False):
  5.     """
  6.     评估回复是否与理想答案匹配
  8.     参数：
  9.     response: 回复的内容
  10.     ideal: 理想的答案
  11.     debug: 是否打印调试信息
  12.     """
  13.     if debug:
  14.         print("回复：")
  15.         print(response)
  17.     # json.loads() 只能解析双引号，因此此处将单引号替换为双引号
  18.     json_like_str = response.replace("'",'"')
  20.     # 解析为一系列的字典
  21.     l_of_d = json.loads(json_like_str)
  23.     # 当响应为空，即没有找到任何商品时
  24.     if l_of_d == [] and ideal == []:
  25.         return 1
  27.     # 另外一种异常情况是，标准答案数量与回复答案数量不匹配
  28.     elif l_of_d == [] or ideal == []:
  29.         return 0
  31.     # 统计正确答案数量
  32.     correct = 0    
  34.     if debug:
  35.         print("l_of_d is")
  36.         print(l_of_d)
  38.     # 对每一个问答对  
  39.     for d in l_of_d:
  41.         # 获取产品和目录
  42.         cat = d.get('category')
  43.         prod_l = d.get('products')
  44.         # 有获取到产品和目录
  45.         if cat and prod_l:
  46.             # convert list to set for comparison
  47.             prod_set = set(prod_l)
  48.             # get ideal set of products
  49.             ideal_cat = ideal.get(cat)
  50.             if ideal_cat:
  51.                 prod_set_ideal = set(ideal.get(cat))
  52.             else:
  53.                 if debug:
  54.                     print(f"没有在标准答案中找到目录 {cat}")
  55.                     print(f"标准答案: {ideal}")
  56.                 continue
  58.             if debug:
  59.                 print("产品集合：\n",prod_set)
  60.                 print()
  61.                 print("标准答案的产品集合：\n",prod_set_ideal)
  63.             # 查找到的产品集合和标准的产品集合一致
  64.             if prod_set == prod_set_ideal:
  65.                 if debug:
  66.                     print("正确")
  67.                 correct +=1
  68.             else:
  69.                 print("错误")
  70.                 print(f"产品集合: {prod_set}")
  71.                 print(f"标准的产品集合: {prod_set_ideal}")
  72.                 if prod_set <= prod_set_ideal:
  73.                     print("回答是标准答案的一个子集")
  74.                 elif prod_set >= prod_set_ideal:
  75.                     print("回答是标准答案的一个超集")
  77.     # 计算正确答案数
  78.     pc_correct = correct / len(l_of_d)
  80.     return pc_correct
  1. print(f'用户提问: {msg_ideal_pairs_set[7]["customer_msg"]}')
  2. print(f'标准答案: {msg_ideal_pairs_set[7]["ideal_answer"]}')
  1. 用户提问: What Gaming consoles would be good for my friend who is into racing games?
  2. 标准答案: {'Gaming Consoles and Accessories': {'ProGamer Racing Wheel', 'ProGamer Controller', 'GameSphere Y', 'GameSphere VR Headset', 'GameSphere X'}}
  1. response = find_category_and_product_v2(msg_ideal_pairs_set[7]["customer_msg"],
  2.                                          products_and_category)
  3. print(f'回答: {response}')
  5. eval_response_with_ideal(response,
  6.                               msg_ideal_pairs_set[7]["ideal_answer"])
  1. 回答:  
  2.     [{'category': 'Gaming Consoles and Accessories', 'products': ['GameSphere X', 'ProGamer Controller', 'GameSphere Y', 'ProGamer Racing Wheel', 'GameSphere VR Headset']}]
  9. 1.0

9. 计算正确比例

  1. import time
  3. score_accum = 0
  4. for i, pair in enumerate(msg_ideal_pairs_set):
  5.     time.sleep(20)
  6.     print(f"示例 {i}")
  8.     customer_msg = pair['customer_msg']
  9.     ideal = pair['ideal_answer']
  11.     # print("Customer message",customer_msg)
  12.     # print("ideal:",ideal)
  13.     response = find_category_and_product_v2(customer_msg,
  14.                                                       products_and_category)
  17.     # print("products_by_category",products_by_category)
  18.     score = eval_response_with_ideal(response,ideal,debug=False)
  19.     print(f"{i}: {score}")
  20.     score_accum += score
  23. n_examples = len(msg_ideal_pairs_set)
  24. fraction_correct = score_accum / n_examples
  25. print(f"正确比例为 {n_examples}: {fraction_correct}")
  1. 示例 0
  2. 0: 1.0
  3. 示例 1
  4. 错误
  5. 产品集合: {'MobiTech Wireless Charger', 'SmartX EarBuds', 'SmartX MiniPhone', 'SmartX ProPhone', 'MobiTech PowerCase'}
  6. 标准的产品集合: {'MobiTech Wireless Charger', 'SmartX EarBuds', 'MobiTech PowerCase'}
  7. 回答是标准答案的一个超集
  8. 1: 0.0
  9. 示例 2
  10. 2: 1.0
  11. 示例 3
  12. 3: 1.0
  13. 示例 4
  14. 错误
  15. 产品集合: {'SoundMax Home Theater', 'CineView 8K TV', 'CineView 4K TV', 'CineView OLED TV', 'SoundMax Soundbar'}
  16. 标准的产品集合: {'CineView 8K TV'}
  17. 回答是标准答案的一个超集
  18. 错误
  19. 产品集合: {'ProGamer Racing Wheel', 'ProGamer Controller', 'GameSphere Y', 'GameSphere VR Headset', 'GameSphere X'}
  20. 标准的产品集合: {'GameSphere X'}
  21. 回答是标准答案的一个超集
  22. 4: 0.3333333333333333
  23. 示例 5
  24. 5: 1.0
  25. 示例 6
  26. 6: 1.0
  27. 示例 7
  28. 7: 1.0
  29. 示例 8
  30. 8: 1.0
  31. 示例 9
  32. 9: 1
  33. 正确比例为 10: 0.8333333333333334